#include <bits/stdc++.h>
using namespace std;

/*
1298. 你能从盒子里获得的最大糖果数
已解答
困难
相关标签
premium lock icon
相关企业
提示
给你 n 个盒子，每个盒子的格式为 [status, candies, keys, containedBoxes] ，其中：

状态字 status[i]：整数，如果 box[i] 是开的，那么是 1 ，否则是 0 。
糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。
给你一个 initialBoxes 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

请你按照上述规则，返回可以获得糖果的 最大数目 。

 

示例 1：

输入：status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
输出：16
解释：
一开始你有盒子 0 。你将获得它里面的 7 个糖果和盒子 1 和 2。
盒子 1 目前状态是关闭的，而且你还没有对应它的钥匙。所以你将会打开盒子 2 ，并得到里面的 4 个糖果和盒子 1 的钥匙。
在盒子 1 中，你会获得 5 个糖果和盒子 3 ，但是你没法获得盒子 3 的钥匙所以盒子 3 会保持关闭状态。
你总共可以获得的糖果数目 = 7 + 4 + 5 = 16 个。
示例 2：

输入：status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
输出：6
解释：
你一开始拥有盒子 0 。打开它你可以找到盒子 1,2,3,4,5 和它们对应的钥匙。
打开这些盒子，你将获得所有盒子的糖果，所以总糖果数为 6 个。
示例 3：

输入：status = [1,1,1], candies = [100,1,100], keys = [[],[0,2],[]], containedBoxes = [[],[],[]], initialBoxes = [1]
输出：1
示例 4：

输入：status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = []
输出：0
示例 5：

输入：status = [1,1,1], candies = [2,3,2], keys = [[],[],[]], containedBoxes = [[],[],[]], initialBoxes = [2,1,0]
输出：7
 

提示：

1 <= status.length <= 1000
status.length == candies.length == keys.length == containedBoxes.length == n
status[i] 要么是 0 要么是 1 。
1 <= candies[i] <= 1000
0 <= keys[i].length <= status.length
0 <= keys[i][j] < status.length
keys[i] 中的值都是互不相同的。
0 <= containedBoxes[i].length <= status.length
0 <= containedBoxes[i][j] < status.length
containedBoxes[i] 中的值都是互不相同的。
每个盒子最多被一个盒子包含。
0 <= initialBoxes.length <= status.length
0 <= initialBoxes[i] < status.length
*/

// 法一
class Solution {
public:
    int maxCandies(vector<int>& status, vector<int>& candies, vector<vector<int>>& keys, vector<vector<int>>& containedBoxes, vector<int>& initialBoxes) {
        int n = status.size();
        vector<bool> hasBox(n, false); // 记录当前拥有的盒子
        vector<bool> usedKey(n, false); // 记录已经使用过的钥匙
        vector<bool> opened(n, false); // 记录已经打开的盒子
        queue<int> q; // BFS队列，存放可以打开的盒子
        
        // 初始化拥有的盒子
        for (int box : initialBoxes) {
            hasBox[box] = true;
            if (status[box] == 1) { // 如果盒子是打开的，加入队列
                q.push(box);
                opened[box] = true;
            }
        }
        
        int ans = 0;
        while (!q.empty()) {
            int current = q.front();
            q.pop();
            ans += candies[current]; // 收集糖果
            
            // 处理当前盒子中的钥匙
            for (int key : keys[current]) {
                status[key] = 1; // 用钥匙打开对应的盒子
                usedKey[key] = true;
                if (hasBox[key] && !opened[key]) { // 如果拥有该盒子且未打开，加入队列
                    q.push(key);
                    opened[key] = true;
                }
            }
            
            // 处理当前盒子中包含的其他盒子
            for (int box : containedBoxes[current]) {
                hasBox[box] = true;
                if (status[box] == 1 && !opened[box]) { // 如果盒子是打开的且未处理，加入队列
                    q.push(box);
                    opened[box] = true;
                }
            }
        }
        return ans;
    }
};


// 法二
class Solution {
public:
    int maxCandies(vector<int>& status, vector<int>& candies, vector<vector<int>>& keys, vector<vector<int>>& containedBoxes, vector<int>& initialBoxes) {
        int n = status.size();
        int s[n]; // 用于记录每个盒子的状态：s[i]的二进制位表示是否拥有盒子(bit 0)和是否拥有钥匙(bit 1)
        queue<int> q; // BFS队列，存放当前可以打开的盒子
        memset(s, 0, sizeof(s)); // 初始化状态数组为0
        int res = 0; // 记录最终能获得的糖果总数

        // 初始化处理：检查初始拥有的盒子
        for (auto i : initialBoxes) {
            s[i] |= 1; // 标记bit 0为1，表示拥有这个盒子
            if (status[i] == 1) {
                s[i] |= 2; // 如果盒子本身是打开的，标记bit 1为1（相当于拥有钥匙）
            }
            if (s[i] == 3) { // 3=0b11，表示既有盒子又有钥匙，可以打开
                q.push(i); // 加入待处理队列
            }
        }

        // BFS处理队列中的盒子
        while (q.size()) {
            auto cur = q.front(); // 取出当前要处理的盒子
            q.pop();
            res += candies[cur]; // 收集当前盒子的糖果

            // 处理当前盒子中包含的其他盒子
            for (auto b : containedBoxes[cur]) {
                if (s[b] != 3) { // 如果盒子b还没有被完全处理（既拥有盒子又拥有钥匙）
                    s[b] |= 1; // 标记拥有这个盒子
                    if (status[b] == 1) s[b] |= 2; // 如果盒子b本身是打开的，标记拥有钥匙
                    if (s[b] == 3) { // 如果现在既有盒子又有钥匙
                        q.push(b); // 加入待处理队列
                    }
                }
            }

            // 处理当前盒子中的钥匙
            for (auto b : keys[cur]) {
                if (s[b] != 3) { // 如果盒子b还没有被完全处理
                    s[b] |= 2; // 标记拥有这个盒子的钥匙
                    if (s[b] == 3) { // 如果现在既有盒子又有钥匙
                        q.push(b); // 加入待处理队列
                    }
                }
            }
        }
        return res; // 返回最终收集的糖果总数
    }
};